package demo1;

class MyValue {
    public int value;
}

class MyValue1 {
    //改成private修饰的value 怎么访问
    private int value;

    //有参数的构造方法，来初始化成员属性
    public MyValue1(int value) {
        this.value = value;
    }

    //创建一个接口，可以访问到private修饰的value
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}

class Animal {
    //成员属性
    public String name;
    public int age;

    //成员方法
    public void eat() {
        System.out.println(name + " 在吃饭");
    }

}
class dog extends Animal{
    public void wangwang() {
        System.out.println(super.name + " 在睡觉");
    }

    @Override   //这个表示注解。此注解的功能是检查是否发生重写
    public void eat() {
        System.out.println(name + " 吃狗粮！！");
    }
}
class cat extends Animal {
    @Override
    public void eat() {
        System.out.println(name + " 吃猫粮！！");
    }
}
public class Test {

    public static void func(Animal animal) {
        //利用多态
        animal.eat();  //通过父类来调用这个父类和子类重写的方法
    }
    public static void main(String[] args) {
        Animal animal1 = new dog();
        animal1.name = "小灰";
        Animal animal2 = new cat();
        animal2.name = "小白";

        func(animal1);
        func(animal2);
    }


    //进行交换的一个函数
    public static void swap2(MyValue1 val1,MyValue1 val2) {
        int tmp = val1.getValue();
        val1.setValue(val2.getValue());
        val2.setValue(tmp);
    }
    //改成private封装的值，利用一个接口
    public static void main3(String[] args) {
        //实例化对象
        MyValue1 myValue1 = new MyValue1(0);
        myValue1.setValue(10);

        MyValue1 myValue2 = new MyValue1(1);
        myValue2.setValue(20);
        //交换
        swap2(myValue1,myValue2);

        System.out.println(myValue1.getValue());
        System.out.println(myValue2.getValue());
    }



    //进行交换的一个函数
    public static void swap1(MyValue val1,MyValue val2) {
        int tmp = val1.value;
        val1.value = val2.value;
        val2.value = tmp;
    }

    public static void main2(String[] args) {
        //实例化对象
        MyValue myValue1 = new MyValue();
        myValue1.value = 10;

        MyValue myValue2 = new MyValue();
        myValue2.value = 20;
        //交换
        swap1(myValue1,myValue2);

        System.out.println(myValue1.value);
        System.out.println(myValue2.value);
    }


    //进行交换的一个函数  （错误示范）
    public static void swap(int val1,int val2) {
        int tmp = val1;
        val1 = val2;
        val2 = tmp;
    }
    public static void main1(String[] args) {
        //实例化对象
        MyValue myValue1 = new MyValue();
        myValue1.value = 10;

        MyValue myValue2 = new MyValue();
        myValue2.value = 20;
        //交换
        swap(myValue1.value,myValue2.value);   //注意这样传参是不对的，不能够更改值
        //因为只是在栈上交换了值，原先引用指向的内容并没有改变
        //应该传递引用（相当于数组传递地址）

        System.out.println(myValue1.value);
        System.out.println(myValue2.value);
    }
}
